package com.gs.m_index

import android.content.Context
import android.util.Log
import com.gs.common.API
import com.gs.common.callback.HttpCallback
import com.gs.common.callback.impl.CommonHttpCallback
import com.gs.common.constant.HttpCode
import com.gs.common.constant.StateCode
import com.gs.common.global.GlobalVariables
import com.gs.common.sqlite.UserSqliteOpenHelper
import okhttp3.Call
import okhttp3.Response
import org.json.JSONObject
import java.net.ConnectException
import java.net.SocketTimeoutException

class IndexModel(context: Context) {

    private val api by lazy { API.getInstance() }
    private val userSqliteOpenHelper by lazy { UserSqliteOpenHelper(context) }

    fun autoLogin(block: (Int) -> Unit) {
        block.invoke(StateCode.STATE_LOADING)
        val loginUsers = userSqliteOpenHelper.selectUser()
        if (loginUsers.isNotEmpty()) {
            val loginUser = loginUsers[0]
            val token = loginUser.token
            GlobalVariables.token = token
            Log.d("loginToken", token)
            api.autoLogin(token, object : HttpCallback{
                override fun onSuccess(call: Call, result: String, response: Response) {
                    val cookies = response.header("Set-Cookie")
                    Log.d("cookies", "$cookies")
                    val resultJSON = JSONObject(result)
                    Log.d("result", result)
                    Log.d("code", "${resultJSON["code"]}")
                    if (resultJSON["code"] == HttpCode.SUCCESS_CODE) {
                        GlobalVariables.loginUser = loginUser
                        block.invoke(StateCode.STATE_SUCCESS)
                        return
                    }
                    block.invoke(StateCode.STATE_FAILED)
                }

                override fun onError(call: Call, e: Exception) {
                    when(e) {
                        is ConnectException -> {
                            block.invoke(StateCode.NETWORK_ERROR)
                        }
                        is SocketTimeoutException -> {
                            block.invoke(StateCode.SERVER_ERROR)
                        }
                        else -> {
                            block.invoke(StateCode.UNKNOWN_ERROR)
                        }
                    }
                }

            })
        }
    }

    companion object{
        private var instance: IndexModel? = null

        fun getInstance(context: Context): IndexModel {
            if (instance == null) {
                synchronized(this::class) {
                    if (instance == null) {
                        instance = IndexModel(context)
                    }
                }
            }
            return instance!!
        }
    }
}